home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 August: Tool Chest / Dev.CD Aug 94.toast / New System Software Extensions / OpenDoc A6 / SOM / OpenDoc and SOM / CPlusPlus / ODMemory.xh < prev    next >
Encoding:
Text File  |  1994-04-19  |  10.2 KB  |  431 lines  |  [TEXT/MPS ]
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: Locrian:WWDCSun:CPlusPlus:ODMemory.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: somc/smemit.c
  7.  *     SOM Emitter emitxh.dll: somc/smmain.c
  8.  */
  9.  
  10. /*
  11.  * 
  12.  *  Forward declarations
  13.  * 
  14.  */
  15.  
  16.  
  17. #ifndef SOM_ODMemoryHeap_xh
  18. #define SOM_ODMemoryHeap_xh
  19.  
  20. class ODMemoryHeap;
  21.  
  22. #define ODMemoryHeap_MajorVersion 0
  23. #define ODMemoryHeap_MinorVersion 0
  24.  
  25. /* C++ som defs */
  26. #include <somcls.xh>
  27.  
  28. /* Include C++ parent defs */
  29. #ifndef SOM_SOMObject_xh
  30. #include <somobj.xh>
  31. #endif
  32.  
  33. #ifndef ODMemoryHeap_API
  34. #define ODMemoryHeap_API
  35. /*
  36.  * -- The Class API
  37.  */
  38.  
  39. /*
  40.  * Start of user-defined types:
  41.  */
  42. typedef
  43. unsigned long  ODMemoryHeap_ODBlockSize;
  44.  
  45. /*
  46.  *  ----- Method declarations
  47.  */
  48.  
  49. #ifndef SOM_DONT_USE_SHORT_NAMES
  50. #ifndef SOMTGD_ODBlockSize
  51.     #ifdef ODBlockSize
  52.         #undef ODBlockSize
  53.         #define SOMTGD_ODBlockSize 1
  54.     #else
  55.         #define ODBlockSize ODMemoryHeap_ODBlockSize
  56.     #endif /* ODBlockSize */
  57. #endif /* SOMTGD_ODBlockSize */
  58. #endif /* SOM_DONT_USE_SHORT_NAMES */
  59.  
  60. /*
  61.  * End of user-defined types.
  62.  */
  63.  
  64. #if applec ^ PRAGMA_LIB_EXPORT
  65. #pragma lib_export on
  66. #endif
  67.  
  68.  
  69. /* A procedure to create the ODMemoryHeap Class */
  70. class M_ODMemoryHeap;
  71. SOMEXTERN M_ODMemoryHeap * SOMLINK ODMemoryHeapNewClass(
  72.         integer4 majorVersion,
  73.         integer4 minorVersion);
  74.  
  75. /* The API to the ODMemoryHeap class object, and the methods it introduces. */
  76. typedef struct ODMemoryHeapClassDataStructure {
  77.     M_ODMemoryHeap *classObject;
  78.     somMToken Allocate;
  79.     somMToken BlockSize;
  80.     somMToken BytesAllocated;
  81.     somMToken BytesFree;
  82.     somMToken Free;
  83.     somMToken GetZapOnAllocate;
  84.     somMToken GetZapOnFree;
  85.     somMToken HeapSize;
  86.     somMToken NumberAllocatedBlocks;
  87.     somMToken Reset;
  88.     somMToken Reallocate;
  89.     somMToken SetZapOnAllocate;
  90.     somMToken SetZapOnFree;
  91.     somMToken SetObjectHeap;
  92. } ODMemoryHeapClassDataStructure;
  93. #ifdef SOM_NO_DATA_EXPORTS
  94.    SOMEXTERN ODMemoryHeapClassDataStructure * ODMemoryHeapGetClassData ( void );
  95. #   undef ODMemoryHeapClassData
  96. #   define ODMemoryHeapClassData (*ODMemoryHeapGetClassData())
  97. #else
  98.    SOMEXTERN ODMemoryHeapClassDataStructure ODMemoryHeapClassData;
  99. #endif /* SOM_NO_DATA_EXPORTS */
  100.  
  101. #if applec ^ PRAGMA_LIB_EXPORT
  102. #pragma lib_export off
  103. #endif
  104.  
  105. #define _ODMemoryHeap ODMemoryHeapClassData.classObject
  106.  
  107. /* The API to parentMtabs for ODMemoryHeap, and the instance data it introduces. */
  108. SOMEXTERN struct ODMemoryHeapCClassDataStructure {
  109.     somMethodTabs parentMtab;
  110.     somDToken instanceDataToken;
  111. } ODMemoryHeapCClassData;
  112.  
  113. /*
  114.  * -- Typedefs for Procedures that support Methods introduced by ODMemoryHeap
  115.  */
  116. SOMEXTERN {
  117. typedef void*   (* SOMLINK somTD_ODMemoryHeap_Allocate)(ODMemoryHeap *somSelf, Environment *ev,
  118.         ODMemoryHeap_ODBlockSize size);
  119. typedef ODMemoryHeap_ODBlockSize   (* SOMLINK somTD_ODMemoryHeap_BlockSize)(ODMemoryHeap *somSelf, Environment *ev,
  120.         void* block);
  121. typedef unsigned long   (* SOMLINK somTD_ODMemoryHeap_BytesAllocated)(ODMemoryHeap *somSelf, Environment *ev);
  122. typedef unsigned long   (* SOMLINK somTD_ODMemoryHeap_BytesFree)(ODMemoryHeap *somSelf, Environment *ev);
  123. typedef void   (* SOMLINK somTD_ODMemoryHeap_Free)(ODMemoryHeap *somSelf, Environment *ev,
  124.         void* ptr);
  125. typedef boolean   (* SOMLINK somTD_ODMemoryHeap_GetZapOnAllocate)(ODMemoryHeap *somSelf, Environment *ev);
  126. typedef boolean   (* SOMLINK somTD_ODMemoryHeap_GetZapOnFree)(ODMemoryHeap *somSelf, Environment *ev);
  127. typedef unsigned long   (* SOMLINK somTD_ODMemoryHeap_HeapSize)(ODMemoryHeap *somSelf, Environment *ev);
  128. typedef unsigned long   (* SOMLINK somTD_ODMemoryHeap_NumberAllocatedBlocks)(ODMemoryHeap *somSelf, Environment *ev);
  129. typedef void   (* SOMLINK somTD_ODMemoryHeap_Reset)(ODMemoryHeap *somSelf, Environment *ev);
  130. typedef void*   (* SOMLINK somTD_ODMemoryHeap_Reallocate)(ODMemoryHeap *somSelf, Environment *ev,
  131.         void* block,
  132.         ODMemoryHeap_ODBlockSize newSize);
  133. typedef void   (* SOMLINK somTD_ODMemoryHeap_SetZapOnAllocate)(ODMemoryHeap *somSelf, Environment *ev,
  134.         boolean zapOnAllocate);
  135. typedef void   (* SOMLINK somTD_ODMemoryHeap_SetZapOnFree)(ODMemoryHeap *somSelf, Environment *ev,
  136.         boolean zapOnFree);
  137. }
  138.  
  139. #endif /* ODMemoryHeap_API */
  140.  
  141.  
  142. /*
  143.  * -- Method Tokens are Thunks
  144.  */
  145. #undef somresolve_
  146. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  147.  
  148. /*
  149.  * -- The C++ Wrapper Class for ODMemoryHeap
  150.  */
  151. class ODMemoryHeap : public SOMObject
  152. {
  153. public:
  154.  
  155. void *operator new(size_t size)
  156. {
  157.    SOM_IgnoreWarning(size);
  158.    if (!ODMemoryHeapClassData.classObject) 
  159.       ODMemoryHeapNewClass(ODMemoryHeap_MajorVersion,ODMemoryHeap_MinorVersion);
  160.    return (void *)
  161.       ((somTD_SOMClass_somNew)
  162.       somresolve_((SOMObject *)((void*)(ODMemoryHeapClassData.classObject)),
  163.                  SOMClassClassData.somNew))
  164.          ((SOMClass *)((void*)(ODMemoryHeapClassData.classObject)));
  165. }
  166.  
  167. void operator delete(void * obj)
  168. {
  169.    ((SOMObject *)obj)->somFree();
  170. }
  171.  
  172. /* Override somGetClass for this class to specialize the return type. */
  173. M_ODMemoryHeap* somGetClass()
  174. {
  175.    return (M_ODMemoryHeap *) ((void *)(SOMObject::somGetClass()));
  176. }
  177.  
  178. /* public method: Allocate */
  179. void*   Allocate(Environment *ev,
  180.         ODMemoryHeap_ODBlockSize size)
  181. {
  182.    return SOM_Resolve(this,ODMemoryHeap,Allocate)
  183.     (this,ev,size);
  184. }
  185.  
  186.  
  187. /* public method: BlockSize */
  188. ODMemoryHeap_ODBlockSize   BlockSize(Environment *ev,
  189.         void* block)
  190. {
  191.    return SOM_Resolve(this,ODMemoryHeap,BlockSize)
  192.     (this,ev,block);
  193. }
  194.  
  195.  
  196. /* public method: BytesAllocated */
  197. unsigned long   BytesAllocated(Environment *ev)
  198. {
  199.    return SOM_Resolve(this,ODMemoryHeap,BytesAllocated)
  200.     (this,ev);
  201. }
  202.  
  203.  
  204. /* public method: BytesFree */
  205. unsigned long   BytesFree(Environment *ev)
  206. {
  207.    return SOM_Resolve(this,ODMemoryHeap,BytesFree)
  208.     (this,ev);
  209. }
  210.  
  211.  
  212. /* public method: Free */
  213. void   Free(Environment *ev,
  214.         void* ptr)
  215. {
  216.    SOM_Resolve(this,ODMemoryHeap,Free)
  217.     (this,ev,ptr);
  218. }
  219.  
  220.  
  221. /* public method: GetZapOnAllocate */
  222. boolean   GetZapOnAllocate(Environment *ev)
  223. {
  224.    return SOM_Resolve(this,ODMemoryHeap,GetZapOnAllocate)
  225.     (this,ev);
  226. }
  227.  
  228.  
  229. /* public method: GetZapOnFree */
  230. boolean   GetZapOnFree(Environment *ev)
  231. {
  232.    return SOM_Resolve(this,ODMemoryHeap,GetZapOnFree)
  233.     (this,ev);
  234. }
  235.  
  236.  
  237. /* public method: HeapSize */
  238. unsigned long   HeapSize(Environment *ev)
  239. {
  240.    return SOM_Resolve(this,ODMemoryHeap,HeapSize)
  241.     (this,ev);
  242. }
  243.  
  244.  
  245. /* public method: NumberAllocatedBlocks */
  246. unsigned long   NumberAllocatedBlocks(Environment *ev)
  247. {
  248.    return SOM_Resolve(this,ODMemoryHeap,NumberAllocatedBlocks)
  249.     (this,ev);
  250. }
  251.  
  252.  
  253. /* public method: Reset */
  254. void   Reset(Environment *ev)
  255. {
  256.    SOM_Resolve(this,ODMemoryHeap,Reset)
  257.     (this,ev);
  258. }
  259.  
  260.  
  261. /* public method: Reallocate */
  262. void*   Reallocate(Environment *ev,
  263.         void* block,
  264.         ODMemoryHeap_ODBlockSize newSize)
  265. {
  266.    return SOM_Resolve(this,ODMemoryHeap,Reallocate)
  267.     (this,ev,block,newSize);
  268. }
  269.  
  270.  
  271. /* public method: SetZapOnAllocate */
  272. void   SetZapOnAllocate(Environment *ev,
  273.         boolean zapOnAllocate)
  274. {
  275.    SOM_Resolve(this,ODMemoryHeap,SetZapOnAllocate)
  276.     (this,ev,zapOnAllocate);
  277. }
  278.  
  279.  
  280. /* public method: SetZapOnFree */
  281. void   SetZapOnFree(Environment *ev,
  282.         boolean zapOnFree)
  283. {
  284.    SOM_Resolve(this,ODMemoryHeap,SetZapOnFree)
  285.     (this,ev,zapOnFree);
  286. }
  287.  
  288.  
  289.  
  290. };   /* ODMemoryHeap */
  291.  
  292.  
  293.  
  294. #endif       /* SOM_ODMemoryHeap_xh */
  295.  
  296. #ifndef SOM_M_ODMemoryHeap_xh
  297. #define SOM_M_ODMemoryHeap_xh
  298.  
  299. class M_ODMemoryHeap;
  300.  
  301. #define M_ODMemoryHeap_MajorVersion 0
  302. #define M_ODMemoryHeap_MinorVersion 0
  303.  
  304. /* C++ som defs */
  305. #include <somcls.xh>
  306.  
  307. /* Include C++ parent defs */
  308. #ifndef SOM_SOMClass_xh
  309. #include <somcls.xh>
  310. #endif
  311.  
  312. #ifndef M_ODMemoryHeap_API
  313. #define M_ODMemoryHeap_API
  314. /*
  315.  * -- The Class API
  316.  */
  317.  
  318. /*
  319.  * Start of user-defined types:
  320.  */
  321.  
  322. /*
  323.  * End of user-defined types.
  324.  */
  325.  
  326. /*
  327.  * -- M_ODMemoryHeap is a metaclass for ODMemoryHeap. Make sure ODMemoryHeap is known.
  328.  */
  329. class ODMemoryHeap;
  330.  
  331.  
  332. #if applec ^ PRAGMA_LIB_EXPORT
  333. #pragma lib_export on
  334. #endif
  335.  
  336.  
  337. /* A procedure to create the M_ODMemoryHeap Class */
  338. SOMEXTERN SOMClass * SOMLINK M_ODMemoryHeapNewClass(
  339.         integer4 majorVersion,
  340.         integer4 minorVersion);
  341.  
  342. /* The API to the M_ODMemoryHeap class object, and the methods it introduces. */
  343. typedef struct M_ODMemoryHeapClassDataStructure {
  344.     SOMClass *classObject;
  345.     somMToken ODMemoryHeapCreate;
  346. } M_ODMemoryHeapClassDataStructure;
  347. #ifdef SOM_NO_DATA_EXPORTS
  348.    SOMEXTERN M_ODMemoryHeapClassDataStructure * M_ODMemoryHeapGetClassData ( void );
  349. #   undef M_ODMemoryHeapClassData
  350. #   define M_ODMemoryHeapClassData (*M_ODMemoryHeapGetClassData())
  351. #else
  352.    SOMEXTERN M_ODMemoryHeapClassDataStructure M_ODMemoryHeapClassData;
  353. #endif /* SOM_NO_DATA_EXPORTS */
  354.  
  355. #if applec ^ PRAGMA_LIB_EXPORT
  356. #pragma lib_export off
  357. #endif
  358.  
  359. #define _M_ODMemoryHeap M_ODMemoryHeapClassData.classObject
  360.  
  361. /* The API to parentMtabs for M_ODMemoryHeap, and the instance data it introduces. */
  362. SOMEXTERN struct M_ODMemoryHeapCClassDataStructure {
  363.     somMethodTabs parentMtab;
  364.     somDToken instanceDataToken;
  365. } M_ODMemoryHeapCClassData;
  366.  
  367. /*
  368.  * -- Typedefs for Procedures that support Methods introduced by M_ODMemoryHeap
  369.  */
  370. SOMEXTERN {
  371. typedef ODMemoryHeap*   (* SOMLINK somTD_M_ODMemoryHeap_ODMemoryHeapCreate)(M_ODMemoryHeap *somSelf, Environment *ev,
  372.         unsigned long initialSize,
  373.         unsigned long incrementSize);
  374. }
  375.  
  376. #endif /* M_ODMemoryHeap_API */
  377.  
  378.  
  379. /*
  380.  * -- Method Tokens are Thunks
  381.  */
  382. #undef somresolve_
  383. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  384.  
  385. /*
  386.  * -- The C++ Wrapper Class for M_ODMemoryHeap
  387.  */
  388. class M_ODMemoryHeap : public SOMClass
  389. {
  390. public:
  391.  
  392. void *operator new(size_t size)
  393. {
  394.    SOM_IgnoreWarning(size);
  395.    if (!M_ODMemoryHeapClassData.classObject) 
  396.       M_ODMemoryHeapNewClass(M_ODMemoryHeap_MajorVersion,M_ODMemoryHeap_MinorVersion);
  397.    return (void *)
  398.       ((somTD_SOMClass_somNew)
  399.       somresolve_((SOMObject *)((void*)(M_ODMemoryHeapClassData.classObject)),
  400.                  SOMClassClassData.somNew))
  401.          ((SOMClass *)((void*)(M_ODMemoryHeapClassData.classObject)));
  402. }
  403.  
  404. void operator delete(void * obj)
  405. {
  406.    ((SOMObject *)obj)->somFree();
  407. }
  408.  
  409. /* Override somNew for this Metaclass to specialize the return type. */
  410. ODMemoryHeap* somNew()
  411. {
  412.    return (ODMemoryHeap *) ((void *)(SOMClass::somNew()));
  413. }
  414.  
  415. /* public method: ODMemoryHeapCreate */
  416. ODMemoryHeap*   ODMemoryHeapCreate(Environment *ev,
  417.         unsigned long initialSize,
  418.         unsigned long incrementSize)
  419. {
  420.    return SOM_Resolve(this,M_ODMemoryHeap,ODMemoryHeapCreate)
  421.     (this,ev,initialSize,incrementSize);
  422. }
  423.  
  424.  
  425.  
  426. };   /* M_ODMemoryHeap */
  427.  
  428.  
  429.  
  430. #endif       /* SOM_M_ODMemoryHeap_xh */
  431.